<template>
    <div v-cloak id="wrapper">
        <Header :componentInfoHeader="componentInfoHeader" @showHistory="showHistory" @save="save" @repulseMark="repulse" @submit="submitResult" @closeVersion="closeVersion" @recoverVersion="recoverVersion(null)" />

        <HistoryPopup :hisPopupShow="history.show"
            :historyList="history.list"
            @viewVersion="viewVersion"
            @recoverVersion="recoverVersion"
            @closeHisPopup="history.show = false"/>
        <CenterControl 
            v-if="files.current" 
            :allFiles="files.allInfo" 
            :currentFile="files.current" 
            :currentFileId="files.current.index * 1 + 1" 
            :filesType="files.showType" 
            pageType="mark"
            @changeFileList="changeFileList" 
            @selectData="selectData" 
            @preTask="preTask" 
            @nextTask="nextTask" 
            @markBadData="markBadData" 
            @hideHeader="hideHeader" />

        <FileList v-if="files.current" 
            :listShow="listShow" 
            :showList="files.showList" 
            :currentId="files.current.id" 
            @skipFile="skipFile" />

        <MarkContent ref="MarkContent" :files="files"/>
        <!-- <Dialogs>
            <EditFrom :editCfg='comfimProps.editCfg'
                :editData='comfimProps.editData' ref='editForm  '></EditFrom>
        </Dialogs> -->
    </div>
</template>

<script>
import PageSize from "@/assets/js/pagesize.js"; // 分页插件
import SVG from "svg.js"; // svg图形操作插件
import OcrPublicClass from "@/assets/js/plugin/jingxihuaocr.js"; // ocr业务功能插件
import CompareTxtNew from "@/assets/js/plugin/compare.js"; // 文本对比插件
import Header from "@/components/mark/Header";
import CenterControl from "@/components/mark/centerControl";
import Tool from "@/components/mark/Tool";
import FileList from "@/components/mark/FileList";
import HistoryPopup from "@/components/mark/HistoryPopup"
import MarkContent from "@/components/mark/MarkContent"
let self = null;
let svg = null;
export default {
    name: "mark-page",
    data() {
        return {
            base: {
                batchId: "",
                taskId: "",
                markTaskId: "",
                recheck: null,
                step: 0
            },
            // 头部组件参数
            componentInfoHeader: {
                curName: "", // 文件名
                standardBtnShow: true, // 标注规范显示
                standardCnt: "", // 标注规范内容
                abandonBtnShow: false, // 重新认证按钮显示
                repulseBtnShow: false, // 打回按钮显示
                isRecheck: false, // 是否是复检环节
                saveBtnShow: true, // 保存按钮显示
                historyBtnShow: true, // 历史按钮显示
                shortcutBtnShow: true, //  快捷键展示
                submitBtnShow: true,
                shortcutkeys: [
                    {
                        key: "多边形",
                        value: "Z"
                    },
                    {
                        key: "矩形",
                        value: "A"
                    },
                    {
                        key: "快捷隐藏标记框",
                        value: "Tab"
                    },
                    {
                        key: "取消绘图",
                        value: "Esc"
                    },
                    {
                        key: "快速编辑",
                        value: "双击图形 / 选中 + Enter"
                    },
                    {
                        key: "拖拽图片",
                        value: "Space + 左键"
                    },
                    {
                        key: "撤销多边形绘制点",
                        value: "ctrl + Z"
                    },
                    {
                        key: "删除",
                        value: "右键"
                    }
                ], // 快捷键配置
                showVersionInfo: false // 展示历史按钮
            },
            files: {
                // 文件信息
                lastIndex: 0, // 上次标注的文件id
                allInfo: [], // 全部数据
                showType: 1, // 1 表示全部 2 表示好数据，3表示坏数据，4表示未标注
                showList: [],
                current: null, // 当前的数据
                curIndex: 0, // 当前数据的id
                allImage: [], // 全部的图片
                currentPoint: null // 给点添加标签 新增字段
            }, // 文件相关
            history: {
                show: false, //历史界面显示
                list: [], //历史文件列表
                allList: [],
                curIndex: 0,
                showVersionInfo: false, //历史显然界面显示
                textData: "", // 历史规整内容字符串
                correlationHTML: "", //历史联动内容字符串
                unfoldDomH: {},
                curFiles: null, //当前选中历史记录的文件对象
                hidePop: false,
                getSuccess: false,
                submitsuccess: false
            },
            // comfimProps: {
            //     editCfg : [{
            //         type : 'radio', // textarea
            //         label: '质检结果:',
            //         prop : 'c_submit1',  // editData[prop] == modelTxt
            //         width : '100px',
            //         change : function(val){
            //         }, // change回调
            //         radios: [{// type == radio 单选
            //             label: '合格',
            //             value : 1
            //         },{
            //             label: '不合格',
            //             value : 2
            //         }],
            //     },{
            //         type : 'textarea', // textarea
            //         label: '评价:',
            //         prop : 'c_submit2',  // editData[prop] == modelTxt
            //         width : '260px'
            //     }],
            //     editData: { // 数据对象
            //         'c_submit1' : 1,
            //         'c_submit2' : '1232'
            //     },
            //     editRules: { // 校验规则

            //     }
            // },
            arrowShow: false,
            listShow: false,
            lastType: "click", // 上次选择的绘图类型
            checkboxsGroup: {
                serial: false,
                inHeritAttr: false,
                hierarchy: false,
                showEditPop: false // 绘制完弹弹框 // 快速弹框
            },
            filterBoxShow: false, //筛选框显示
            lebalLebals: false, //选择属性框显示
            checkType: {},
            fastInsertTxtObj: {},
            drapSrlDom: null, // 拖拽区域中的拖拽d元素om
            promptShow: {
                shortcuts: false, // 快捷键
                standard: false, // 规范显示
                selFiles: 1
            },

            vm: {
                // 配置参数
                leaveEnd: false,
                el: "drawing", // SVG 挂载点
                height: "100%", // SVG 渲染高度
                width: "100%", // SVG 渲染宽度
                type: "click", // 当前绘图的类型
                currentDrawData: {}, // 当前绘制图形的属性值
                currentId: 0, // 当前标注的文件序列 唯一不重复即可
                selectId: "", // 当前选中的 SVG 图像的id  主要为了获取当前选择的图形id
                list: [], // 图形数据 由于层级关系 需要用到
                isDisableRightKey: true, // 是否禁用右键
                zoom: 1, // 缩放比例
                maxZoom: 15, // 最大缩放比例
                minZoom: 0.02, // 最小缩放比例
                strokeWidth: 2, // 生成线的大小
                dragPointSize: 10, // 拖拽点的 大小
                textSize: 12, // 文本默认大小
                rotateDeg: 1, // 0 0, 1 90, 2 180 , 3  270,
                imgData: {
                    // 图片的基本信息
                    imgPath:
                        "http://ainote.iflytek.com/static/images/reg_bg.jpg", // http://127.0.0.1:8081/static/img/test.3036edb.jpg
                    width: 0,
                    height: 0,
                    x: 0,
                    y: 0
                },
                canChooseP: true, //是否开启选中多边形呢的折线
                svgHightLightClass: "svg-highlight", // 高亮的calss
                currentPolyLineId: "", // 当前折线的id
                clickCallBack: this.setClick, // 点击的回掉函数
                successCallBack: this.successCallBack, // 绘图结束后的回掉
                drawFailCallBack: this.drawFailCallBack, // 绘制失败回调
                imgLoadCallBack: this.imgLoadCallBack, // svg img绘图成功后的回调
                changeCallBack: this.changeCallBack, // 图形修改后的回调
                pointMouseDown: this.pointCallBack,
                svgNodeClickCallBack: this.svgNodeClickCallBack, // svg单击回调函数
                svgNodeDblclickCallBack: this.svgNodeDblclickCallBack, // svg双击回调函数
                pointContextmenuCallback: this.pointContextmenuCallback, // 点右击事件
                dragPointMoveCallback: this.dragPointMoveCallback, // 拖拽点移动回调
                graphicsMoveCallback: this.graphicsMoveCallback // 图形移动回调
            },
            refresh: 0, // 参考参数
            temItem: null, // 拖拽中间数据源
            successNum: 0, // 序列号
            preListsObj: null, // 保存上一个操作的list列表中图形信息对象 避免遍历
            selDrapClass: "",
            cursorLocation: 0, // 光标的位置 供快速插入使用
            operate: {
                autoSaveInterval: null, // 定时器自动保存
                isKeydownPrepare: true // 输入框是否获取焦点，默认没有
            },
            drawOver: false,
            ctrlDown: false,
            requiredLabel: true,
            isTranscription: true,
            isPointLabel: true, // 必须给点打标签
            banDrop: false,
            roboting: false, //机器转写
            tipYc: true, // tip隐藏
            hierarchyId: "", // 继承层级的ID
            downCanWheel: true, // 可以上滑动标识
            upCanWheel: true, // 可以下滑动标识
            poppupShow: false, // 快速编辑弹框展示
            pointPopupShow: false, // 点标记框展示
            isRightCls: false, // 关闭右边区域
            modifyTipsShow: false, // 修改率浮层
            textareaFocus: false, //
            markAverageRate: "--", // 标注环节平均修改率
            checkAverageRate: "--", // 检查环节平均修改率
            qualityAverageRate: "--", // 质检环节平均修改率
            readOnly: [
                "not-care",
                "other-language",
                "Korean",
                "formula",
                "apostrophe",
                "machineprint"
            ], // readOnly的属性 machineprint 印刷
            MytaskList: "",
            task: {},
            task_type: "mark",
            apply_type: "custom",
            single_min: 0,
            single_max: 0,
            count_level: [],
            countVal: null,
            currPage: 1,
            pageSize: 10,
            postData: {
                taskType: "", //任务类型：0-标注任务；1-检查任务；2-质检任务
                progressType: "0", //任务完成情况：0-未完成；1-已完成
                taskName: "", //任务名称
                taskStatus: ""
            }
        };
    },
    // 同步原始数据拉取
    async created() {
        self = this;
        self.base.taskId = self.Utils.getQueryStringArgs()["taskId"];
        //markTaskId
        self.base.markTaskId = self.Utils.getQueryStringArgs()["markTaskId"];

        if (self.Utils.getQueryStringArgs().recheck === "recheck") {
            self.base.recheck = 1;
        } else {
            self.base.recheck = 0;
        }
        // ass_api.getFileInfo(markTaskId, function (info) {
        const getFileListPromise = self.ass_api.getFileListNew({
            // 复检功能
            markTaskId: self.base.markTaskId,
            markFileId: "all",
            recheck: self.base.recheck
        });
        await getFileListPromise.then(info => {
            if (!info) return;
            info = JSON.parse(info);
            var step = info.step;
            if (!(step == 0 || step == 1 || step == 2))
                return self.ui.error("获取文件异常");
            if (info.files.length == 0) return self.ui.error("获取文件个数为0");

            ///////////////
            self.componentInfoHeader.curName = info.markName;
            self.componentInfoHeader.standardCnt = info.markStandard;
            console.log(self.base.recheck, 'self.base.recheck')
            if (step === 1) {
                // 检查环节有打回
                if (!self.base.recheck) {
                    // 主平台复检
                    self.componentInfoHeader.repulseBtnShow = true;
                } else {
                    self.componentInfoHeader.isRecheck = true;
                }
            } else if (step === 2) {
                if (!self.base.recheck) {
                    // 主平台复检
                    self.componentInfoHeader.repulseBtnShow = true;
                } else {
                    self.componentInfoHeader.isRecheck = true;
                }
            }

            self.base.step = step;
            self.base.batchId = info.batchId;

            self.base.markTaskId = info.markTaskId;
            self.requiredLabel = info.pageElement.requiredLabel; // 是否必选标签
            self.isTranscription = info.pageElement.isTranscription; // 是否必选转写
            self.isPointLabel = info.pageElement.isPointLabel; // 是否给点打标签

            if (step == 0) {
                $("title").text("精细化标注");
            } else if (step == 1) {
                $("title").text("精细化检查");
            } else if (step == 2) {
                $("title").text("精细化质检");
            }

            var files = info.files; // 过滤出后台返回来的files
            var lastIndex = info.lastIndex * 1;

            // self.getCurResult(self.files.allInfo[self.files.curIndex]) // 获取最新数据 同步
            var labels = info.pageElement.labels;
            for (let i = 0; i < labels.length; i++) {
                self.fastInsertTxtObj[labels[i].ename] = labels[i].cname;
            }
            for (let i = 0; i < info.pageElement.propertyLabels.length; i++) {
                self.checkType[info.pageElement.propertyLabels[i].ename] =
                    info.pageElement.propertyLabels[i].cname;
            }

            self.initFiles(info.files, info.lastIndex);
            // self.operate.autoSaveInterval = setInterval(function() {
            //     // 20s一次 查看历史的时候跳过执行
            //     if (!( self.history.show == true || self.history.showVersionInfo == true)) {
            //         // self.getCurrentFocusElement() 新方案 不需要
            //         self.saveCheckData(true) && self.saveResult(true, true); // 自动，异步
            //     }
            // }, 20000);
        });
        // 快捷键事件绑定
        this.shortcutKeyEvent();
    },
    mounted() {
        document.documentElement.addEventListener("contextmenu", function(e) {
            if (self.drawOver) {
                self.drawOver = false;
                return;
            }
            self.delectSelectBox(true);
        });
    },
    computed: {
        // 新增
        showList: function() {
            // 展示的
            this.refreshList();
            var info = [],
                re = this.refresh;
            setRightList(this.vm.list, info);

            function setRightList(data, info) {
                data.forEach(function(data, index) {
                    if (data.children) {
                        info.push(data);
                        setRightList(data.children, info);
                    } else {
                        info.push(data);
                    }
                });
            }
            return info;
        },
        finishNum: function() {
            // 查看标注完成个数
            var len = this.files.allInfo.length,
                result = 0;
            if (len == 0) return "--";
            for (var i = 0; i < len; i++) {
                if (this.files.allInfo[i].status == 1) {
                    result++;
                }
            }
            return result;
        },
        dataLength: function() {
            var dataL = [0, 0, 0, 0];
            if (!this.files || !this.files.allInfo) {
                return dataL;
            }
            var len = this.files.allInfo.length,
                info = this.files.allInfo;
            dataL[0] = len;
            for (var i = 0; i < len; i++) {
                if (info[i].isBad === 0) {
                    //好数据
                    dataL[1]++;
                }
                if (info[i].isBad === 1) {
                    // 坏数据
                    dataL[2]++;
                }
                if (info[i].status === 0) {
                    // 未标注
                    dataL[3]++;
                }
            }
            return dataL;
        },
        pageModifyRate: function() {
            // 页面要展示的修改率  bcjia 修改
            if (/^p-|^r-\d/g.test(this.vm.selectId)) {
                return true;
            } else {
                return false;
            }
        },
        averageModifyRate: function() {
            // 平均修改率
            var sumModify = 0,
                val = "";
            if (this.showList) {
                this.showList.forEach(function(item) {
                    sumModify +=
                        self.base.step === 0
                            ? item.markModifyRate
                            : self.base.step === 1
                                ? item.checkModifyRate
                                : self.base.step === 2
                                    ? item.qualityModifyRate
                                    : "";
                });
            }
            val = parseInt(sumModify / this.showList.length * 100) / 100;
            val = val ? val : 0;
            if (self.base.step === 0) {
                this.markAverageRate = val;
            } else if (self.base.step === 1) {
                this.checkAverageRate = val;
            } else if (self.base.step === 2) {
                this.qualityAverageRate = val;
            }
            return val;
        },
        singleModifyRate: function() {
            if (self.base.step === 0) {
                return this.vm.currentDrawData.markModifyRate;
            } else if (self.base.step === 1) {
                return this.vm.currentDrawData.checkModifyRate;
            } else if (self.base.step === 2) {
                return this.vm.currentDrawData.qualityModifyRate;
            }
        }
    },
    methods: {
        // 子组件点击事件
        changeFileList(listShowType) {
            this.listShow = listShowType;
        },
        hideHeader(showType) {
            console.log(showType, "showTypeshowTypeshowTypeshowType");
            this.arrowShow = showType;
        },
        shortcutKeyEvent() {
            document.onkeydown = function(e) {
                // keydown事件
                // if(self.operate.isKeydownPrepare === false) return;
                var e = e || window.event,
                    code = e.keyCode || e.which || e.charCode;

                var type = e.srcElement ? e.srcElement.type : e.target.type; // 看当前所处环境
                var ableToDo = true; // 用来区分是否可以使用快捷键
                var upDown = true; // 是否可以 上下 切换 2018/9/28
                if (type === "text" || type === "textarea") {
                    // 如果在文本框中
                    ableToDo = false;
                }

                // self.rectanglePolygon(self.vm.selectId);
                if (type === "textarea") {
                    // 如果在 textarea 中 2018/9/28
                    upDown = false;
                }
                self.Utils.shortKeyIfTrue(
                    code == 90 && ableToDo,
                    function() {
                        // shift + z  多边形 e.shiftKey && code == 90
                        if (e.ctrlKey) return;
                        self.sendclickType(2);
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    code == 9 && ableToDo,
                    function() {
                        // 快速编辑快捷键 code == 9 Table
                        if (e.ctrlKey) return;
                        if (
                            !self.poppupShow &&
                            self.vm.selectId != "defaultGroup"
                        ) {
                            // 打开弹窗
                            self.svgNodeDblclickCallBack({
                                offsetX: 0,
                                offsetY: 0
                            });
                        } else {
                            // 关闭弹窗
                            self.poppupShow = false;
                        }
                    },
                    e
                );

                self.Utils.shortKeyIfTrue(
                    code == 65 && ableToDo,
                    function() {
                        // shift + z  矩形  e.ctrlKey && self.mouseState === 1
                        if (e.ctrlKey) return;
                        self.sendclickType(1);
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    code == 32 && ableToDo,
                    function() {
                        // 拖拽 115 code == 32
                        if (e.ctrlKey) return;
                        self.sendclickType(6);
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    code == 69 && ableToDo,
                    function() {
                        // 下一条 e
                        self.nextTask();
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    code == 81 && ableToDo,
                    function() {
                        // 上一条 q
                        self.preTask();
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    code == 83 && ableToDo,
                    function() {
                        // 筛选框 s
                        self.filterBoxShow = !self.filterBoxShow;
                    },
                    e
                );
                // self.Utils.shortKeyIfTrue(code == 88 && ableToDo, function () { // 折线 x
                //     if(e.ctrlKey) return;
                //     self.sendclickType(3);
                // }, e);
                self.Utils.shortKeyIfTrue(
                    code == 13 && ableToDo,
                    function() {
                        // 快速编辑 选中 + Enter
                        self.quickEditFn();
                    },
                    e
                );

                self.Utils.shortKeyIfTrue(
                    code == 67 && ableToDo,
                    function() {
                        // 继承层级
                        if (
                            self.history.showVersionInfo ||
                            self.history.show
                        )
                            return;
                        self.checkboxsGroup.hierarchy = !self.checkboxsGroup
                            .hierarchy;
                        self.inheritHierarchy();
                    },
                    e
                );

                self.Utils.shortKeyIfTrue(
                    code == 27 && ableToDo,
                    function() {
                        // 取消绘图 Y
                        svg.cancelDraw(); // 取消正在绘制
                        svg.initCursor(); // 初始化光标
                        self.drawOver = true;
                        self.vm.type = "click"; // 初始化绘制类型
                        self.lastType = "click"; // 初始化上次绘制类型
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    e.ctrlKey && code == 90 && ableToDo,
                    function() {
                        //  撤销折线控制点 ctrl + z
                        svg.revokePolygon();
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    e.ctrlKey && ableToDo,
                    function() {
                        //  ctrl键按下
                        self.ctrlDown = true;
                    },
                    e
                );
                self.Utils.shortKeyIfTrue(
                    code == 46 && ableToDo,
                    function() {
                        if (self.drawOver) {
                            self.drawOver = false;
                            return;
                        }
                        self.delectSelectBox(true);
                    },
                    e
                );
            };

            document.onkeyup = function(e) {
                // keyup事件
                var e = e || window.event,
                    code = e.keyCode || e.which || e.charCode;
                var type = e.srcElement ? e.srcElement.type : e.target.type; // 看当前所处环境
                var ableToDo = true; // 用来区分是否可以使用快捷键
                self.ctrlDown = false;
                if (type === "text" || type === "textarea") {
                    // 如果在文本框中
                    ableToDo = false;
                }
                // 空格
                self.Utils.shortKeyIfTrue(
                    code == 32 && ableToDo,
                    function() {
                        // 拖拽 115 code == 32
                        self.sendclickType(self.lastType);
                    },
                    e
                );
            };
        },
        robot: function() {
            var url = "/open/robot";
            window.open(url);
        },
      
        /**
         * 数据渲染
         */
        refreshList: function() {
            for (var i = 0, len = this.vm.list.length; i < len; i++) {
                var item = this.vm.list[i];
                if (item.unfold) {
                    // 右侧list列表 是否展开
                    self.$set(item, "unfold", true);
                } else {
                    self.$set(item, "unfold", false);
                }
                if (item.type === undefined) {
                    self.$set(item, "type", "");
                }
                // 设置cid 与 别名
                item.cid = i + 1;
                if (!item.isFirst) {
                    self.$set(item, "alias", i + 1 + "");
                } else {
                    self.$set(item, "alias", "");
                }
                item.parent = null;
                handleChildrenItem(item, item.alias);
            }

            this.successNum = i + 1;
            // this.refresh ++;
            function handleChildrenItem(item, p_alias) {
                var firstId = null; // 每次调用应该是重置
                if (item && item.children && item.children.length != 0) {
                    for (var i = 0, len = item.children.length; i < len; i++) {
                        var c = item.children[i];
                        if (c.unfold) {
                            // 右侧list列表 是否展开
                            self.$set(c, "unfold", true);
                        } else {
                            self.$set(c, "unfold", false);
                        }
                        if (c.type === undefined) {
                            self.$set(c, "type", "");
                        }
                        c.cid = i + 1;
                        c.alias = p_alias + "-" + c.cid;
                        if (i + 1 > firstId && firstId !== null) {
                            c.cid = i;
                        } else {
                            c.cid = i + 1;
                        }

                        if (!c.isFirst) {
                            self.$set(c, "alias", p_alias + "-" + c.cid);
                        } else {
                            self.$set(c, "alias", "");
                            firstId = i + 1;
                        }

                        // 设置父元素
                        c.parent = item;
                        handleChildrenItem(c, c.alias, firstId);
                    }
                }
            }
        },
        /**
         * 数据初始化
         * @param files
         * @param lastIndex
         */
        initFiles: function(files, lastIndex) {
            // 遍历循环全部数据
            var self = this;
            var len = files.length,
                curIndex = 0;
            for (var i = 0; i < len; i++) {
                var item = files[i],
                    dInfo = {};
                var extend = item.extend;
                try {
                    // 标注默认结果
                    dInfo = item.defaultResult;
                    dInfo = dInfo;
                } catch (e) {
                    dInfo = [];
                }

                dInfo.forEach(function(info) {
                    // bcjia  (machineTxt 赋值)
                    info.machineTxt = info.text
                        ? info.text
                        : info.machineTxt ? info.machineTxt : ""; // bcjia 修改
                    info.markTxt = info.markTxt ? info.markTxt : "";
                    info.checkTxt = info.checkTxt ? info.checkTxt : "";
                    info.markModifyRate =
                        info.markModifyRate !== undefined
                            ? info.markModifyRate
                            : "--";
                    info.checkModifyRate =
                        info.checkModifyRate !== undefined
                            ? info.checkModifyRate
                            : "--";
                    info.qualityModifyRate =
                        info.qualityModifyRate !== undefined
                            ? info.qualityModifyRate
                            : "--";
                    info.markAverageRate =
                        info.markAverageRate !== undefined
                            ? info.markAverageRate
                            : "--"; // 标注平均修改率 存在赋值 不存在--
                    info.checkAverageRate =
                        info.checkAverageRate !== undefined
                            ? info.checkAverageRate
                            : "--"; // 检查平均修改率  存在赋值 不存在--
                    info.qualityAverageRate =
                        info.qualityAverageRate !== undefined
                            ? info.qualityAverageRate
                            : "--"; // 质检平均修改率  存在赋值 不存在--
                    try {
                        if (self.readOnly.indexOf(info.type) > -1) {
                            // 如果是5个默认结果 则清空
                            info.text = "";
                        }
                    } catch (e) {}
                });

                var result = this.flatToTreeData(dInfo);

                if (self.Utils.isNotNull(item)) {
                    // 文件不为空 直接赋值到全部数据
                    var url = this.ass_api.getFileUrl({
                        key: "u-" + self.base.markTaskId + "-" + item.id,
                        sid: self.Utils.getCookie("sid")
                    });
                    self.files.allInfo.push({
                        result: result, // 把扁平数据树结构化 供前端逻辑使用
                        averageRate1: result[0]
                            ? result[0].markAverageRate
                            : "--",
                        averageRate2: result[0]
                            ? result[0].checkAverageRate
                            : "--",
                        averageRate3: result[0]
                            ? result[0].qualityAverageRate
                            : "--",
                        isBad: item.isBad,
                        name: item.name,
                        id: item.id,
                        index: item.id,
                        status: item.status,
                        url: url, // 图片url
                        isInit: 0, // 表示尚未从结果服务获取数据
                        saveSuccess: true
                    });
                    self.files.allImage.push(url); // 所有的图片
                    if (item.id * 1 === lastIndex * 1) {
                        curIndex = i;
                    }
                }
            }

            self.selectData(1, curIndex); // 选择数据
            self.preLoading(self.files.allImage.shift()); // 预加载 img
        },

 


 


        /**
         * 标记点
         */
        setPointSign: function(type) {
            var currentPoint = this.files.currentPoint,
                currentArea = this.vm.currentDrawData;
            var pointInd = currentPoint.data("point-index");
            if (type === "top") {
                self.$set(this.vm.currentDrawData, "startPoint", [
                    currentPoint.cx(),
                    currentPoint.cy()
                ]);
                self.$set(this.vm.currentDrawData, "startPointInd", pointInd);
                if (
                    currentArea.endPoint &&
                    KeepEight(currentArea.endPoint[0]) ===
                        KeepEight(currentPoint.cx()) &&
                    KeepEight(currentArea.endPoint[1]) ===
                        KeepEight(currentPoint.cy())
                ) {
                    self.$set(this.vm.currentDrawData, "endPoint", null);
                    self.$set(this.vm.currentDrawData, "endPointInd", -1);
                }
            } else if (type === "bottom") {
                self.$set(this.vm.currentDrawData, "endPoint", [
                    currentPoint.cx(),
                    currentPoint.cy()
                ]);
                self.$set(this.vm.currentDrawData, "endPointInd", pointInd);
                if (
                    currentArea.startPoint &&
                    KeepEight(currentArea.startPoint[0]) ===
                        KeepEight(currentPoint.cx()) &&
                    KeepEight(currentArea.startPoint[1]) ===
                        KeepEight(currentPoint.cy())
                ) {
                    self.$set(this.vm.currentDrawData, "startPoint", null);
                    self.$set(this.vm.currentDrawData, "startPointInd", -1);
                }
            } else if (type === "normal") {
                var currentX = currentPoint.cx(),
                    currentY = currentPoint.cy();
                if (
                    currentArea.startPoint &&
                    KeepEight(currentArea.startPoint[0]) ===
                        KeepEight(currentX) &&
                    KeepEight(currentArea.startPoint[1]) === KeepEight(currentY)
                ) {
                    self.$set(this.vm.currentDrawData, "startPoint", null);
                    self.$set(this.vm.currentDrawData, "startPointInd", -1);
                } else if (
                    currentArea.endPoint &&
                    KeepEight(currentArea.endPoint[0]) ===
                        KeepEight(currentX) &&
                    KeepEight(currentArea.endPoint[1]) === KeepEight(currentY)
                ) {
                    self.$set(this.vm.currentDrawData, "endPoint", null);
                    self.$set(this.vm.currentDrawData, "endPointInd", -1);
                }
            }
            // 变色
            $(".adjust-size").each(function(ind, item) {
                var cx = $(item).attr("cx"),
                    cy = $(item).attr("cy");
                $(item).css({
                    fill: "rgb(0, 162, 255)"
                });
                $(item).attr("point-type", ""); // dom上添加标记
                if (
                    currentArea.startPoint &&
                    KeepEight(currentArea.startPoint[0]) === KeepEight(cx) &&
                    KeepEight(currentArea.startPoint[1]) === KeepEight(cy)
                ) {
                    $(item).css({
                        fill: "red"
                    });
                    $(item).attr({
                        "point-type": "startPoint",
                        title: "上边界点"
                    }); // dom上添加标记
                }
                if (
                    currentArea.endPoint &&
                    KeepEight(currentArea.endPoint[0]) === KeepEight(cx) &&
                    KeepEight(currentArea.endPoint[1]) === KeepEight(cy)
                ) {
                    $(item).css({
                        fill: "green"
                    });
                    $(item).attr({
                        "point-type": "endPoint",
                        title: "下边界点"
                    }); // dom上添加标记
                }
            });
        },





        /**
         * 图片预加载
         * @param img 图片地址
         */
        preLoading: function(img) {
            if (!img) {
                return false;
            }
            var oImg = new Image(),
                url = "";
            oImg.src = img;
            if (oImg.complete) {
                url = self.files.allImage.shift();
                //如果图片已经存在于浏览器缓存,直接调用回调函数
                self.preLoading(url);
            } else {
                oImg.onload = function() {
                    url = self.files.allImage.shift();
                    //如果图片已经存在于浏览器缓存,直接调用回调函数
                    self.preLoading(url);
                };
            }
        },






        // 删除选中的图形
        delectSelectBox: function(kj) {
            var _Vue = this;
            this.poppupShow = false; // 快速编辑框 关闭
            var delObj = []; // 保存嵌套删除的对象
            if (this.history.showVersionInfo || this.history.show) {
                // 如果查看历史不准删除
                _Vue.ableKey = true;
                return false;
            }
            var id = this.vm.selectId; // 当前选中的矩形
            var status = false;
            this.lebalLebals = false; // 关掉打属性框
            if (id === "defaultGroup" || !id) {
                // 如果当前id不是绘图框
                if (!kj) {
                    self.ui.fade("当前尚未选择图形");
                }
                _Vue.ableKey = true;
                /*setTimeout(function () {
                            _Vue.ableKey = true;
                        },1000);*/
            } else {
                var tsTxt = "是否删除当前选中的图形",
                    yTxt = "确定",
                    nTxt = "取消";
                // children中是否存在折线
                var hasPolyline =
                    self.vm.currentDrawData.children &&
                    self.vm.currentDrawData.children[0]
                        ? self.vm.currentDrawData.children.some(function(item) {
                              return item.region == "polyline";
                          })
                        : "";
                if (!hasPolyline && hasPolyline === false) {
                    // 不存在折线
                    tsTxt = "是否同时删除嵌套图形";
                    (yTxt = "只删除选中图形"), (nTxt = "同时删除所有嵌套图形");
                }
                if (hasPolyline) {
                    // 存在折线
                    tsTxt = "是否删除选中多边形及所有折线";
                    (yTxt = "删除"), (nTxt = "只删除第一条折线");
                }
                // 提示框
                self.ui
                    .dialogs("操作提醒", tsTxt, yTxt, nTxt)
                    .then(function() {
                        // 删除当前元素
                        try {
                            // delete _Vue.vm.list[id]; // 删除
                            var list = _Vue.vm.list;
                            if (!!hasPolyline) {
                                delListItem(list, false); // 内部有折线默认全删除
                            } else {
                                delListItem(list, true);
                            }
                            svg.clearDrawPoint(); // 清空 拖拽点
                            SVG.get(id).remove(); // 清空图形
                            SVG.get(id + "-text").remove(); // 删除文字
                            SVG.get(id + "-group") &&
                                SVG.get(id + "-group").remove(); // 清空父容器 折线么有group
                            _Vue.vm.selectId = ""; // 删除过后 应该将当前选中的id 清空
                            _Vue.ableKey = true;
                            self.$set(_Vue.vm, "currentDrawData", {});
                        } catch (e) {
                            // console.log(e)
                            self.ui.fade("当前尚未选择图形");
                            _Vue.ableKey = true;
                        }
                        self.closeSignPopup();
                    })
                    .catch(action => {
                        if (action === "close") return; // 点击叉关闭弹框 不执行关闭逻辑
                        if (tsTxt == "是否同时删除嵌套图形") {
                            try {
                                // delete _Vue.vm.list[id]; // 删除
                                var list = _Vue.vm.list;
                                svg.clearDrawPoint(); // 清空 拖拽点
                                SVG.get(id).remove(); // 清空图形
                                SVG.get(id + "-text").remove(); // 删除文字
                                SVG.get(id + "-group") &&
                                    SVG.get(id + "-group").remove(); // 清空父容器 折线么有group
                                delListItem(list, false);
                                _Vue.vm.selectId = ""; // 删除过后 应该将当前选中的id 清空
                                _Vue.ableKey = true;
                                self.$set(_Vue.vm, "currentDrawData", {});
                            } catch (e) {
                                console.log(e);
                                self.ui.fade("当前尚未选择图形");
                                _Vue.ableKey = true;
                            }
                        }
                        if (tsTxt == "是否删除选中多边形及所有折线") {
                            try {
                                // delete _Vue.vm.list[id]; // 删除
                                var list = _Vue.vm.list;
                                // svg.clearDrawPoint(); // 清空 拖拽点
                                // SVG.get(id).remove(); // 清空图形
                                // SVG.get(id + '-text').remove(); // 删除文字
                                // SVG.get(id + '-group') ? SVG.get(id + '-group').remove() : ''; // 清空父容器 折线么有group
                                delListItem(list, false, true);
                                // _Vue.vm.selectId = ''; // 删除过后 应该将当前选中的id 清空
                                _Vue.ableKey = true;
                                // self.$set(_Vue.vm, 'currentDrawData', {});
                            } catch (e) {
                                console.log(e);
                                self.ui.fade("当前尚未选择图形");
                                _Vue.ableKey = true;
                            }
                        }
                        _Vue.ableKey = true;
                    });

                // 递归删除图形方法
                /**
                 *  isYes false 同时删除所有子元素 true 只删除自己
                 *  delFirst true 删除第一条折线
                 */
                function delListItem(list, isYes, delFirst) {
                    for (var i = 0; i < list.length; i++) {
                        if (list[i].id == id) {
                            var childrenArr = list[i].children;
                            if (!!delFirst) {
                                for (var i = 0; i < childrenArr.length; i++) {
                                    if (childrenArr[i].isFirst) {
                                        self.$nextTick(function() {
                                            SVG.get(childrenArr[i].id).remove(); // 清空图形
                                            SVG.get(childrenArr[i] + "-text") &&
                                                SVG.get(
                                                    childrenArr[i] + "-text"
                                                ).remove(); // 删除文字
                                            childrenArr.splice(i, 1);
                                            var newFirstLine = self.setLine(
                                                id,
                                                list
                                            );
                                            // 是否需要关闭继承层级开关
                                            if (
                                                newFirstLine &&
                                                self.hierarchyId ===
                                                    newFirstLine.id
                                            ) {
                                                self.checkboxsGroup.hierarchy = false;
                                            }
                                            // 新的第一条折线 要判断内部是否存在子元素 有的全删
                                            if (
                                                newFirstLine &&
                                                (newFirstLine.children &&
                                                    newFirstLine.children[0])
                                            ) {
                                                removeDom(
                                                    newFirstLine.children
                                                );
                                                newFirstLine.children = [];
                                            }
                                        });
                                        break;
                                    }
                                }
                                return self.refresh++; // 触发更新
                            }
                            var oldPid = list[i].pId;
                            list.splice(i, 1); // 当前这一项 删除
                            if (childrenArr && childrenArr[0]) {
                                if (!isYes) {
                                    removeDom(childrenArr);
                                } else {
                                    for (
                                        var j = childrenArr.length - 1;
                                        j >= 0;
                                        j--
                                    ) {
                                        childrenArr[j].pId = oldPid; // 删除父级 重置原来子级的pId
                                        list.splice(i, 0, childrenArr[j]);
                                    } // 子元素插进来
                                }
                            }
                            self.refresh++; // 触发更新
                            return false;
                        }
                        // console.log(list)
                        if (list[i].children && list[i].children[0]) {
                            var children = list[i].children;
                            if (
                                delListItem(children, isYes, delFirst) === false
                            )
                                return false;
                        }
                    }
                }
                // 递归删除dom节点
                function removeDom(lists) {
                    lists.forEach(function(item) {
                        SVG.get(item.id) && SVG.get(item.id).remove(); // 清空图形
                        SVG.get(item.id + "-text") &&
                            SVG.get(item.id + "-text").remove(); // 删除文字
                        SVG.get(item.id + "-group") &&
                            SVG.get(item.id + "-group").remove(); // 清空父容器 折线么有group
                        if (item.children && item.children[0]) {
                            removeDom(item.children);
                        }
                    });
                }
            }
        },

        // 初始化后套返回扁平数据转换树状结构
        flatToTreeData: function(lists) {
            var tempMap = {};
            lists ? lists : (lists = []); // 返回的值 是否存在
            for (var i = 0, len = lists.length; i < len; i++) {
                var item = lists[i];
                item.parent = null;
                item.children = [];
                tempMap[item.id] = item;
                // 2019/3/21 新需求 兼容云盘导入的默认属性
                if (item.type && self.checkType[item.type] === undefined) {
                    self.$set(self.checkType, item.type, item.type);
                }
            }
            var newArr = [];
            for (var i = 0, len = lists.length; i < len; i++) {
                var item = lists[i];
                if (item.pId != -1 && item.pId != undefined) {
                    var parent = tempMap[item.pId];
                    if (parent) {
                        // 有可能被删了 但pId可能没被修改
                        parent.children.push(item);
                    } else {
                        var aliasArr = item.alias.split("-"),
                            aliasLen = aliasArr.length,
                            aliasStr = "";
                        if (aliasLen > 1) {
                            aliasArr.pop();
                            aliasStr = aliasArr.join("-");
                            var isHas = false;
                            for (var k in tempMap) {
                                if (tempMap[k].alias === aliasStr) {
                                    // 存在alias相同
                                    tempMap[k].children.push(item);
                                    isHas = true;
                                    break;
                                }
                            }
                            if (!isHas) {
                                // 不存在alias相同
                                item.pId = -1;
                                newArr.push(item);
                            }
                        } else {
                            // 自身就在第一层 但存在pId
                            item.pId = -1;
                            newArr.push(item);
                        }
                    }
                } else {
                    newArr.push(item);
                }
            }
            return newArr;
        },
        // 树状数据转扁平 供保存使用
        treeToFlatData: function(lists) {
            var info = [];
            setRightList(lists, info);

            function setRightList(data, info, itemPrt) {
                data.forEach(function(item, index) {
                    info.push({
                        alias: item.alias,
                        cid: item.cid,
                        id: item.id,
                        pointnum: item.pointnum,
                        points: item.points,
                        region: item.region,
                        startPoint: item.startPoint,
                        startPointInd: item.startPointInd,
                        endPointInd: item.endPointInd,
                        endPoint: item.endPoint,
                        text: item.text,
                        type: item.type,
                        pId: item.parent
                            ? itemPrt.id
                            : item.pId === undefined ? -1 : item.pId,
                        isFirst: item.isFirst,
                        x: item.x,
                        y: item.y,
                        w: item.w,
                        h: item.h,
                        machineTxt: !!item.machineTxt ? item.machineTxt : "",
                        markTxt:
                            self.base.step === 0
                                ? item.text
                                : item.markTxt ? item.markTxt : "",
                        checkTxt:
                            self.base.step === 1
                                ? item.text
                                : item.checkTxt ? item.checkTxt : "",
                        markModifyRate: item.markModifyRate,
                        checkModifyRate: item.checkModifyRate,
                        qualityModifyRate: item.qualityModifyRate,
                        markAverageRate: item.markAverageRate,
                        checkAverageRate: item.checkAverageRate,
                        qualityAverageRate: item.qualityAverageRate
                    });
                    if (item.children && item.children[0]) {
                        setRightList(item.children, info, item);
                    }
                });
            }
            return info;
        },

        async showHistory() {
            var self = this;
            this.closeSignPopup();
            if (!self.getFile().result) {
                return self.ui.error("无任务");
            }
            this.history.list = [];
            var fileId = self.getFile().id;
            await this.ass_api
                .getHistoryList(self.base.taskId, self.base.markTaskId, fileId)
                .then(info => {
                    if (!info) return;
                    var len = info.length;
                    for (var i = 0; i < len; i++) {
                        self.history.list.unshift(info[i]);
                    }
                });
            self.history.show = true;
            self.setClick("svgImage");
        },
        getSelectClass: function(_type) {
            if (_type == this.files.showType) {
                return "selected";
            }
        },
        /**
         *  选择区域数据
         * @param _type
         * @param lastIndex
         */
        selectData: function(_type, lastIndex) {
            // 显示历史时 禁止切换
            if (this.history.showVersionInfo) return;
            // 选择对应的数据
            if (!!!this.dataLength[_type - 1]) return;
            // 图片未加载完成 且 不是全部数据
            if (!self.interactive.currentFinished && _type !== 1) {
                // 切换需要做限制
                this.ui.fade("当前图片尚未加载完毕");
                return false;
            }
            if (isNaN(Number(lastIndex))) {
                // 如果 lastIndex 无非转换成数字 默认0
                lastIndex = 0;
            }
            this.poppupShow = false; // 快速编辑框 关闭

            self.files.showType = _type;
            var len = self.files.allInfo.length,
                showList = [];

            if (_type === 1) {
                // 全部数据
                showList = self.files.allInfo;
            } else {
                for (var i = 0; i < len; i++) {
                    var item = self.files.allInfo[i];
                    if (item.isBad === 0 && _type === 2) {
                        // 好数据
                        // console.log(2)
                        showList.push(item);
                    } else if (item.isBad === 1 && _type === 3) {
                        // 坏数据
                        // console.log(3)
                        showList.push(item);
                    } else if (item.status === 0 && _type === 4) {
                        // 未标注
                        // console.log(4)
                        showList.push(item);
                    }
                }
            }
            var len2 = showList.length;
            for (var i = 0; i < len2; i++) {
                var file = showList[i];
                file.last = i == 0 ? null : showList[i - 1];
                file.next = i == len - 1 ? null : showList[i + 1];
            }
            self.files.showList = showList; // 给当前列表赋值

            self.selectFile(self.files.showList[lastIndex]);
        },
        /**
         * 选择单个文件
         * @param item 当前条的数据
         */
        async selectFile (item) {
            var self = this;
            if (self.Utils.isNull(item)) {
                // self.initAboutImgData(true); // 初始化所有和图片相关的信息
                self.files.curIndex = -1;
                self.$set(self.files, "current", {});
                return false;
            } // 如果空 返回
            // if(item.isLoad === undefined){ // 没有校验图片合法
            await this.checkImg(item); // 等待图片加载完 判断图片是否可用
            self.files.curIndex = item.id;
            // 这里先赋值 数据
            self.$set(self.files, "current", item);
            if (!item.isLoad) {
                // 没有校验图片合法
                self.ui.dialogs("操作提醒",'<div style="text-align:center;padding: 24px 0;font-size:18px">当前图片加载失败</div>',
                        { confirmButtonText: "重新加载", cancelButtonText: "数据标坏", type: "warning"}
                    ).then(() => {
                        self.selectFile(item);
                    }).catch(async action => {
                        if (action === "close") return;
                        if (!item.isInit) {
                            // 如果第一次直接获取结果服务
                            await self.getCurResult(item);
                            self.calculateModificationRate(item.result); // 计算修改率
                        }
                        self.markBadData("", true);
                        self.interactive.currentFinished = true; // 初始化 可以不用写
                    });
                return;
            }

            self.initFile(item);
        },
        // 检查图片是否可用
        checkImg(item, cb) {
            var img = new Image();
            img.onload = function() {
                item.isLoad = true;
                return Promise.reject()
                // cb();
            };
            img.onerror = function() {
                item.isLoad = false;
                return Promise.reject()
            };
            img.src = item.url;
        },
        /**
         * 初始化单个文件
         * @param item
         */
        async initFile(item) {
            // if(!item.isLoad){
            //     self.interactive.currentFinished = true; // 初始化
            //     return; // 图片不合法退出
            // }
            // 判断是否获取最新结果 并初当前加载参数
            await self.getCurResult(item);
            if (!item.isInit) {
                // 如果第一次直接获取结果服务
                self.calculateModificationRate(item.result); // 计算修改率

            } 
            this.$refs.MarkContent.$emit('selectFile', item) // 通知子组件 重置组件

        },
        /**
         * 从结果服务中获取是否存在新的结果
         * @param file
         */
        async getCurResult(file) {
            if (file.isInit === 1) return false; // 如果文件 isInit为 1 说明页面刷新后已经从结果拉去过一次
            // 表示需要获取最新的标注数据
            const getCurrentResult = this.ass_api.getCurrentResult(
                self.base.taskId,
                self.base.markTaskId,
                file.id
            );
            await getCurrentResult.then(info => {
                if (!info) return;
                var curInfo = JSON.parse(info.resultText);
                var extend = info.extend;
                var curInfo = self.flatToTreeData(curInfo);
                curInfo
                    ? curInfo.forEach(function(item) {
                          if (item.markAverageRate === undefined) {
                              item.markAverageRate = "--";
                          }
                          if (item.checkAverageRate === undefined) {
                              item.checkAverageRate = "--";
                          }
                          if (item.qualityAverageRate === undefined) {
                              item.qualityAverageRate = "--";
                          }
                      })
                    : "";

                curInfo[0] && (file.averageRate1 = curInfo[0].markAverageRate);
                curInfo[0] && (file.averageRate2 = curInfo[0].checkAverageRate);
                curInfo[0] &&
                    (file.averageRate3 = curInfo[0].qualityAverageRate);

                file.result = curInfo;
                file.isBad = info.extend.stamp;
                file.isInit = 1;
                file.lastSubmit = {
                    result: "", // JSON.stringify(self.arrToObject(file.result, false)),
                    isLastAuto: info.autoSave
                };
            });
        },
        /**
         * 跳转到某一条数据
         * @param item 数据
         * @param force 是否强制跳转 ，如果true 则可以跳到未标注的数据上
         * @returns {boolean}
         */
        skipFile: function(item, force) {
            if (item.status === 0 && !force) {
                this.ui.fade("不能跳转到未标注数据");
                return false;
            }
            if (item.id !== self.files.curIndex) {
                const savePromise = self.saveResult(false);
                if (!savePromise) return;
                // self.saveResult(false)
                self.selectFile(item);
            }
        },
 




        // 下一条
        nextTask: function() {
            if (this.history.showVersionInfo || this.history.show)
                return;
            this.closeSignPopup();
            var file = self.getFile();
            if (self.Utils.isNull(file.next)) {
                self.ui.fade("已是最后一条");
                return false;
            }
            const savePromise = self.saveResult(false);
            if (savePromise) {
                // 下一条触发保存 自动异步
                self.selectFile(file.next);
                self.preListsObj && (self.preListsObj.unfold = false);
                self.lebalLebals = false;
            }
        },
        // 上一条
        preTask: function() {
            // 暂时不触发保存
            if (this.history.showVersionInfo || this.history.show)
                return;
            this.closeSignPopup();
            var file = self.getFile();
            if (self.Utils.isNull(file.last)) {
                self.ui.fade("已是第一条");
                return false;
            }
            const savePromise = self.saveResult(false);

            if (savePromise) {
                // 上一条触发保存 自动异步
                self.selectFile(file.last);
                self.preListsObj ? (self.preListsObj.unfold = false) : "";
                self.lebalLebals = false;
            }

            // self.selectFile(file.last);
        },
        // 获取某个文件
        getFile: function(_fileIndex) {
            if (_fileIndex === undefined) {
                return self.files.current;
            }
            var len = self.files.showList.length;
            for (var i = 0; i < len; i++) {
                var item = self.files.showList[i];
                if (item.index == _fileIndex) {
                    self.selectFile(item);
                    return item;
                }
            }
            return null;
        },
        // 主要用来调用保存方法
        async save() {
            const savePromise = self.saveResult(false);
            savePromise &&
                (await savePromise.then(() => {}).catch(err => {
                    // ass_api.error(err, self.base.step);
                }));
        },
        saveCheckData(isAuto) {
            var file = self.getFile();
            // isOk = false; // 返回值，通知是否可用继续执行
            if (!file.result) {
                if (isAuto) {
                    return; // 没有结果
                } else {
                    self.ui.fade("没有可保存任务");
                    return;
                }
            }
            var flatData = self.treeToFlatData(file.result);
            // 多边形提交 点的格式字符串转成数组
            flatData.forEach(function(item) {
                if (item.region == "area") {
                    item.points = self.polygonToNeed(item.points);
                } else if (item.region == "polyline") {
                    if (
                        typeof item.points != "object" &&
                        typeof item.points == "string"
                    ) {
                        // 折线point格式 保存时 再过滤一遍 确保保存的是[ [0,0] , [1,2] ]数组的格式
                        item.points = self.polygonToNeed(item.points);
                    }
                }
                if (self.base.step === 0) {
                    item.markAverageRate = self.markAverageRate; // 标注平均修改率
                } else if (self.base.step === 1) {
                    item.checkAverageRate = self.checkAverageRate; // 检查平均修改率
                    item.markAverageRate = file.averageRate1;
                } else if (self.base.step === 2) {
                    item.qualityAverageRate = self.qualityAverageRate; // 检查平均修改率
                    item.markAverageRate = file.averageRate1;
                    item.checkAverageRate = file.averageRate2;
                }
            });

            var submitData = JSON.stringify(flatData);

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            var count = 0,
                content = ""; // 属性
            if (!file.isLoad) return true;
            if (!self.interactive.currentFinished) {
                self.ui.fade("当前图片尚未加载完毕");
                return false;
            }

            for (var i = 0; i < flatData.length; i++) {
                var itemReadOnly = self.readOnly.indexOf(flatData[i].type) > -1; // bcjia修改
                if (flatData[i].text.length > 1000) {
                    // 如果内容超过 1000个字
                    if (!isAuto) {
                        self.ui.fade("内容框文字不能超过1000字符");
                        self.setClick(flatData[i].id);
                        return false;
                    }
                }
                if (
                    self.requiredLabel &&
                    flatData[i].region != "polyline" &&
                    !!!flatData[i].type
                ) {
                    if (!isAuto) {
                        self.ui.fade("当前批次任务必须选择属性");
                        self.setClick(flatData[i].id);
                        return false;
                    }
                }
                if (
                    self.isTranscription &&
                    !flatData[i].isFirst &&
                    !!!flatData[i].text &&
                    !itemReadOnly
                ) {
                    // bcjia
                    if (!isAuto) {
                        self.ui.fade("当前批次任务必须进行转写");
                        self.setClick(flatData[i].id);
                        return false;
                    }
                }
                if (
                    self.isPointLabel &&
                    (!!!flatData[i].startPoint || !!!flatData[i].endPoint)
                ) {
                    if (!isAuto) {
                        self.ui.fade("当前批次任务必须进行标记点");
                        self.setClick(flatData[i].id);
                        return false;
                    }
                }
                count++;
            }

            if (!count && !self.files.current.isBad) {
                if (!isAuto) {
                    self.ui.fade("至少需要一个绘图框"); // 至少需要一个标记属性的绘图框
                }
                return false;
            }

            try {
                content = submitData;
            } catch (e) {
                content = "{}";
            }

            if (content === "{}") {
                return false;
            }
            return true;
        },
        /**
         * 保存方法
         * @param isAuto 是否自动
         * @param async 是否异步   改造后同步异步通过async await完成 不通过参数
         * @param success 成功回调
         * @param errorMethod 失败回调
         */
        saveResult: function(isAuto, success, errorMethod) {
            let file = self.getFile();
            let flatData = self.treeToFlatData(file.result);
            let submitData = JSON.stringify(flatData);

            // 校验结果数据
            if (!this.saveCheckData()) return false;
            // 判断数值是否有更改
            // 自动 判断文本变化，无论上次是手动还是自动保存
            // 手动 上次是自动，则不比较文本变化，如果上次是手动则比较变化
            // 文本是否有变化，有变化保存，没有变化判断是否是自动保存和手动保存下上次也是手动保存
            // 2018/8/20 增加了判断 只有当文件
            // if (self.Utils.isNotNull(file.lastSubmit) && self.Utils.isNotNull(file.lastSubmit.result) && file.lastSubmit.result == submitData && file.status == 1) {
            if (
                self.Utils.isNotNull(file.lastSubmit) &&
                self.Utils.isNotNull(file.lastSubmit.result) &&
                file.lastSubmit.result == submitData
            ) {
                if (isAuto || file.lastSubmit.isLastAuto === isAuto) {
                    // isAuto == true 或者 isAuto 和 lastIsAuto 都为false 表示上次也是手动存储的
                    // ui.fade("结果已保存"); //没有变化只给提示
                    file.lastSubmit.isLastAuto = isAuto;
                    //  if(!isAuto){ file.status = 1;} // 如果是手动保存，则更改保存状态
                    // success ? success() : "";
                    // isOk = true;
                    return Promise.resolve();
                }
            }

            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            var params = {
                lastIndex: file.id,
                result: {
                    markTaskFileId: file.id,
                    batchId: self.base.batchId,
                    markTaskId: self.base.markTaskId,
                    stamp: file.isBad,
                    isCheck: false,
                    resultText: submitData,
                    autoSave: isAuto
                }
            };

            file.saveSuccess = false; // 设置 保存状态
            self.interactive.saveSuccess = false; // 默认设置当前数据请求尚未保存成功
            // 先修改status代表已标注 测试
            return self.ass_api
                .saveResult(
                    {
                        markTaskId: self.base.markTaskId,
                        markFileId: file.id,
                        recheck: self.base.recheck
                    },
                    params
                )
                .then(data => {
                    // 保存成功
                    if (!isAuto) {
                        file.status = 1;
                    } // 已标注
                    file.saveSuccess = true;
                    // file.status = 1;
                    file.lastSubmit = {
                        isLastAuto: isAuto,
                        result: submitData
                    };
                    return;
                })
                .catch(err => {
                    file.saveSuccess = false; // 保存失败
                    self.interactive.saveSuccess = true; // 数据请求成功
                    // errorMethod ? errorMethod(err) : "";
                    return Promise.reject(err);
                });
        },





        // 标为坏数据或者好数据
        markBadData: function(e, hCheck) {
            if (this.history.showVersionInfo || this.history.show) {
                // 如果查看历史
                return false;
            }

            var file = self.getFile();

            if (hCheck) {
                file.isBad = 1; // 修改当前文件状态
                // self.destoryAllDraw(); // 删除数据 删除框
                // self.saveResult(false, true, function() {
                //     file.status = 1; // 代表当前已经标注
                //     // self.next(); // 标坏自动跳转下一条
                // }); // 并保存
                const savePromise = self.saveResult(false);
                savePromise &&
                    savePromise.then(() => {
                        file.status = 1; // 代表当前已经标注
                        // self.next(); // 标坏自动跳转下一条
                    });
                return;
            }
            if (file.isBad == 0) {
                if (!self.operate.isKeydownPrepare) {
                    return false;
                }
                self.operate.isKeydownPrepare = false;
                self.ui
                    .confirm("标记为坏数据后，已标注内容将被清除")
                    .then(() => {
                        // 删除当前元素
                        self.operate.isKeydownPrepare = true;
                        file.isBad = 1; // 修改当前文件状态
                        self.destoryAllDraw(); // 删除数据 删除框
                        // self.saveResult(false, true, function() {
                        //     file.status = 1; // 代表当前已经标注
                        //     self.next(); // 标坏自动跳转下一条
                        // }); // 并保存
                        const savePromise = self.saveResult(false);
                        savePromise &&
                            savePromise.then(() => {
                                file.status = 1; // 代表当前已经标注
                                self.nextTask(); // 标坏自动跳转下一条
                            });
                    })
                    .catch(action => {
                        // action === 'cancel' 点击取消按钮
                        // action === 'close' 点击叉
                        self.operate.isKeydownPrepare = true;
                    });
            } else {
                if (file.isLoad) {
                    file.isBad = 0;
                } else {
                    self.ui.fade("当前图片不可用，不可标为好数据");
                }
            }
        },
        // 销毁图标上的所有框
        destoryAllDraw: function() {
            // 清空数据
            this.files.current.result = [];
            this.vm.list = []; // 重新赋值了，不会改变其他引用的值
            this.vm.currentDrawData = {};
            var area_box_group = SVG.select(".area-box-group");
            var adjust_size = SVG.select(".adjust-size");
            area_box_group.each(function() {
                this.remove();
            });
            adjust_size.each(function(item) {
                this.remove();
            });
        },
        /**
         *  提交
         */
        async submitResult() {
            var len = self.files.allInfo.length;

            function skipUnSave(_p) {
                if (self.files.showType != 1) {
                    self.selectData(1);
                }
                self.skipFile(_p, true);
            }

            function prejudgeSubmit() {
                for (var i = 0; i < len; i++) {
                    var item = self.files.allInfo[i];
                    if (item.status == 0) {
                        self.ui.fade(
                            item.name + " 未完成标注,请完成标注后提交"
                        );
                        skipUnSave(item);
                        return false;
                    }
                    if (!item.saveSuccess) {
                        self.ui.fade(item.name + " 保存失败，不能完成提交");
                        skipUnSave(item);
                        return false;
                    }
                }
                return true;
            }
            const savePromise = self.saveResult(false);
            if (self.base.step == 0) {
                savePromise &&
                    (await savePromise
                        .then(() => {
                            if (prejudgeSubmit()) {
                                // 标注提交
                                self.operate.isKeydownPrepare = false; // 2018/8/17 只有成功进入弹框
                                self.ui
                                    .confirm("任务已完成，确认提交？")
                                    .then(() => {
                                        self.operate.isKeydownPrepare = true; // 2018/8/17 成功后 取消
                                        self.ass_api
                                            .submitTask(
                                                self.base.markTaskId,
                                                ""
                                            )
                                            .then(() => {
                                                self.ui.fade("提交成功...");
                                                clearInterval(
                                                    self.operate
                                                        .autoSaveInterval
                                                );
                                                self.history.submitsuccess = true;
                                                // self.closeResult();
                                            });
                                    })
                                    .catch(action => {
                                        self.operate.isKeydownPrepare = true; // 2018/8/17 成功后 取消
                                    });
                            }
                        })
                        .catch(err => {
                            // ass_api.error(err, self.base.step);
                        }));
                // self.operate.isKeydownPrepare = true;
            } else if (self.base.step == 1) {
                // 检查提交
                savePromise &&
                    (await savePromise
                        .then(() => {
                            if (prejudgeSubmit()) {
                                self.operate.isKeydownPrepare = false; // 2018/8/17 只有成功进入弹框
                                // 检查提交弹窗
                                self.ui
                                    .check_confirm(
                                        "操作",
                                        "评价:",
                                        undefined,
                                        "提交"
                                    )
                                    .then(() => {
                                        self.ui
                                            .confirm("任务已完成，确认提交？")
                                            .then(() => {
                                                self.operate.isKeydownPrepare = true; // 2018/8/17 只有成功进入弹框
                                                self.ass_api
                                                    .submitTask(
                                                        self.base.markTaskId,
                                                        JSON.stringify({
                                                            isQualified: 0,
                                                            evaluate: content
                                                        })
                                                    )
                                                    .then(() => {
                                                        self.ui.fade(
                                                            "提交成功..."
                                                        );
                                                        clearInterval(
                                                            self.operate
                                                                .autoSaveInterval
                                                        );
                                                        self.history.submitsuccess = true;
                                                        // self.closeResult();
                                                    });
                                            })
                                            .catch(action => {
                                                self.operate.isKeydownPrepare = true; // 2018/8/17 只有成功进入弹框
                                            });
                                        return true;
                                    })
                                    .catch(action => {
                                        self.operate.isKeydownPrepare = true; // 2018/8/17 只有成功进入弹框
                                        return true;
                                    });
                            }
                        })
                        .catch(err => {
                            // ass_api.error(err, self.base.step);
                        }));
            } else if (self.base.step == 2) {
                // 质检提交
                savePromise &&
                    (await savePromise
                        .then(() => {
                            if (prejudgeSubmit()) {
                                self.operate.isKeydownPrepare = false; // 2018/8/17 只有成功进入弹框
                                // 质检提交弹窗
                                self.ui
                                    .custom_comfirm()
                                    .then(data => {
                                        var content = data.evaluate.trim();
                                        self.ui
                                            .confirm("任务已完成，确认提交？")
                                            .then(() => {
                                                self.operate.isKeydownPrepare = true; // 2018/8/17 只有成功进入弹框
                                                self.ass_api
                                                    .submitTask(
                                                        self.base.markTaskId,
                                                        JSON.stringify({
                                                            isQualified:
                                                                data.isQualified,
                                                            evaluate: content
                                                        })
                                                    )
                                                    .then(() => {
                                                        self.ui.fade(
                                                            "提交成功..."
                                                        );
                                                        clearInterval(
                                                            self.operate
                                                                .autoSaveInterval
                                                        );
                                                        self.closeResult();
                                                    });
                                            })
                                            .catch(action => {
                                                self.operate.isKeydownPrepare = true; // 2018/8/17 只有成功进入弹框
                                            });
                                        return true;
                                    })
                                    .catch(action => {
                                        self.operate.isKeydownPrepare = true; // 2018/8/17 只有成功进入弹框
                                        return true;
                                    });
                            }
                        })
                        .catch(err => {
                            // ass_api.error(err, self.base.step);
                        }));
            }
        },
        // 关闭
        closeResult: function() {
            this.Utils.closeResult(self.base.step);
        },
        /**
         * 由于公用的 fade 无法满足需求
         * @param t 提示内容
         */
        // addFade: function(t) {
        //     var html = $('<i class="fade_e">' + t + "</i>");
        //     $("body").append(html);
        //     html.css("margin-left", -(html.width() + 32) / 2);
        //     var hideOut = function() {
        //         html.animate({opacity: 0}, "normal",function() {
        //             html.remove();
        //         });
        //     };
        //     setTimeout(hideOut, 2000);
        // },
        // 查看历史结果
        async viewVersion(item) {
            this.checkboxsGroup.serial = false;
            this.checkboxsGroup.inHeritAttr = false;
            var fileId = self.getFile().id;
            self.history.show = false;
            self.history.showVersionInfo = true;
            self.vm.type = "click"; // 初始化 类型
            await this.ass_api
                .getHistoryInfo(
                    self.base.taskId,
                    self.base.markTaskId,
                    fileId,
                    item.version
                )
                .then(info => {
                    if (!info) return; //
                    self.history.current = self.flatToTreeData(
                        JSON.parse(info.resultText)
                    ); // 当前历史数据
                    self.history.beforeIsBad = self.files.current.isBad; // 保存之前的好坏数据
                    self.history.beforeHistoryData = self.treeToFlatData(
                        self.files.current.result
                    ); // 切换历史前的数据 简单的深拷贝
                    self.destoryAllDraw(); // 销毁当前所有的图形和数据
                    svg.destroyEvents("mousemove"); // 销毁默认拖动事件
                    svg.bindEvents("mousemove", self.customDrag, 1); // 自定义拖动事件
                    // self.files.current.result = self.flatToTreeData(JSON.parse(item.resultText));
                    self.$set(
                        self.files.current,
                        "result",
                        self.flatToTreeData(JSON.parse(info.resultText))
                    );
                    self.files.current.isBad = info.extend.stamp; // 好坏数据赋值
                });
            self.dataConversion(self.files.current.result, true, true); // 重新绘图并赋值
        },
        // 自定义拖动事件 只有 拖拽有用
        customDrag: function(e) {
            if (this.vm.type === "drag" && svg.dm.drawStatus) {
                // 如果是拖动,切符合拖动条件
                svg.getPoint(e, 0); // 首先获取当前点
                svg.svgToMoveDrag(e); // 移动
            }
            svg.initWheelPoint(); // 初始化滚动参数
        },
        // 开发到此....................
        // 恢复历史结果 (是否传入参数)
        async recoverVersion(pInfo) {
            var result = null;
            var fileId = self.getFile().id;
            if (self.Utils.isNull(pInfo)) {
                // 暂时不做处理 因为已经处理过了
                svg.destroyEvents("mousemove"); // 销毁 之前自定义的事件
                svg.addBaseEvent("mousemove"); // 添加mousemove事件
            } else {
                // 直接绘图
                self.destoryAllDraw(); // 销毁当前所有的图形和数据
                await this.ass_api
                    .getHistoryInfo(
                        self.base.taskId,
                        self.base.markTaskId,
                        fileId,
                        pInfo.version
                    )
                    .then(pInfo => {
                        result = self.flatToTreeData(
                            JSON.parse(pInfo.resultText)
                        );
                        self.$set(self.files.current, "result", result); // 赋值
                        self.files.current.isBad = pInfo.extend.stamp; // 好坏数据赋值
                    });

                self.dataConversion(self.files.current.result, true, true); // 重新绘图并赋值
            }
            const savePromise = self.saveResult(true); // 异步自动 无回调逻辑
            self.history.show = false;
            self.history.showVersionInfo = false;
        },
        // 关闭历史结果
        closeVersion: function() {
            self.history.show = false;
            self.history.showVersionInfo = false;
            self.vm.type = "click"; // 初始化 类型
            self.history.current = {}; // 重新赋值 并不会影响到 原引用指向的值
            self.destoryAllDraw(); // 销毁当前所有的图形和数据
            svg.destroyEvents("mousemove"); // 销毁 之前自定义的事件
            svg.addBaseEvent("mousemove"); // 添加mousemove事件
            self.$set(
                self.files.current,
                "result",
                self.flatToTreeData(self.history.beforeHistoryData)
            );
            self.files.current.isBad = self.history.beforeIsBad; // 恢复之前的好坏数据
            self.history.beforeHistoryData = {}; // 清空保存的数据
            self.dataConversion(self.files.current.result, true, true); // 重新绘图并赋值
            self.setClick("svgImage");
        },
        // 快速编辑
        quickEditFn: function() {
            var id = this.vm.selectId;
            if (!id) return;
            var list = this.showList,
                ind = -1;
            for (var i = 0; i < list.length; i++) {
                if (list[i].id == id) {
                    this.selAttrFn("", i, list[i]);
                    ind = i;
                    break;
                }
            }
            if (ind != -1) {
                this.$nextTick(function() {
                    setTimeout(function() {
                        $(self.$refs[list[ind].id][0]).focus();
                    });
                });
            }
        },
        // 打回
        async repulse() {
            // 检查环节的打回操作
            const savePromise = self.saveResult(false);
            savePromise &&
                (await savePromise
                    .then(() => {
                        self.operate.isKeydownPrepare = true;
                        self.ui
                            .check_confirm(
                                "打回操作",
                                "打回操作",
                                undefined,
                                "提交"
                            )
                            .then(val => {
                                var content = val.value;
                                if (self.base.step === 1) {
                                    // 主平台复检
                                    self.ass_api
                                        .submitTask(
                                            self.base.markTaskId,
                                            JSON.stringify({
                                                isQualified: 1,
                                                evaluate: content
                                            })
                                        )
                                        .then(() => {
                                            self.ui.successGoBase(
                                                "打回成功..."
                                            );
                                            self.closeResult(self.base.step);
                                        });
                                } else if (self.base.step === 2) {
                                    // 主平台复检
                                    self.ass_api
                                        .repulseTask(
                                            self.base.markTaskId,
                                            JSON.stringify({
                                                isQualified: 1,
                                                evaluate: content
                                            })
                                        )
                                        .then(() => {
                                            self.ui.successGoBase(
                                                "打回成功..."
                                            );
                                            self.closeResult();
                                        });
                                }
                                self.operate.isKeydownPrepare = true;
                                return true;
                            })
                            .catch(action => {
                                self.operate.isKeydownPrepare = true;
                                return true;
                            });
                    })
                    .catch(err => console.log(err))); // 注意await的promise回调，一定要加上catch
        },


        // 全局关闭选择标签框和列表合并
        globalCloseUnfold: function() {
            this.lebalLebals = false;
            this.preListsObj ? (this.preListsObj.unfold = false) : "";
        },
        // 关闭弹窗
        closeSignPopup: function() {
            this.pointPopupShow = false;
            this.poppupShow = false;
        },

  

        // 复检新增
        GetQueryString: function(name) {
            //流转任务时获取batchid
            var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
            var r = window.location.search.substr(1).match(reg);
            if (r != null) return unescape(r[2]);
            return null;
        },
        executNow() {
            var self = this;
            self.postData.currPage = 1;
            self.postData.pageSize = self.pageSize;
            //查询结果获取
            var loadList = function(data) {
                if (
                    data.list == undefined ||
                    data.list == null ||
                    data.list == ""
                )
                    return;
                if (data.count == self.MytaskList) {
                    self.ui.fade("任务下发中,请稍后点击！");
                } else {
                    data.list.sort(function(a, b) {
                        return b.createTime * 1 - a.createTime * 1;
                    });
                    var markTaskId = data.list[0].markTaskId;
                    var url =
                        "/assets/home/mark-page/?taskId=" +
                        this.base.taskId +
                        "&markTaskId=" +
                        markTaskId;
                    window.open(url);
                    self.closeResult();
                }
            };
            this.ass_api.pageNav(self.postData).then(loadList);
        },
        getMytaskList() {
            var self = this;
            self.postData.currPage = 1;
            self.postData.pageSize = self.pageSize;
            //查询结果获取
            var loadList = function(data) {
                if (
                    data.list == undefined ||
                    data.list == null ||
                    data.list == ""
                )
                    return;
                self.MytaskList = data.count;
            };
            this.ass_api.pageNav(self.postData).then(loadList);
        },
        doApply: function(taskId, step, count) {
            var self = this;
            var url =
                "/v1/be/task/apply?taskId=" +
                this.base.taskId +
                "&step=" +
                step +
                "&sync=true";
            if (step == 0) {
                // 标注
                var params = {};
                var data = [];
                var item = {};
                item.count = parseInt(count);
                // 此参数不可删除
                item.userid = "";
                data.push(item);
                params.data = data;
                params.hasCount = true;
                LoadAjax.method(
                    url,
                    JSON.stringify(params),
                    "POST",
                    function(data) {
                        if (data == undefined || data == "") {
                            return;
                        }
                        //if (data.rt.status == 200) {
                        if (
                            data.rt.status == 200 &&
                            eval("(" + data.data + ")")[0].count > 0
                        ) {
                            self.history.getSuccess = true;
                            return;
                        } else {
                            if (data.rt.status == 400004) {
                                self.ui.error(lang.member_list_view_msg14);
                                return;
                            } else if (data.rt.status == 400005) {
                                self.ui.error(lang.member_list_view_msg15);
                                return;
                            }
                            self.ui.error(lang.member_list_view_msg16);
                        }
                    },
                    false
                );
            } else if (step == 1) {
                // 检查
                var params = {};
                var data = [];
                var item = {};
                // 此参数不可删除
                item.userid = "";
                data.push(item);
                params.data = data;
                params.hasCount = true;
                LoadAjax.method(
                    url,
                    JSON.stringify(params),
                    "POST",
                    function(data) {
                        if (data == null || data == "") {
                            return;
                        }
                        if (
                            data.rt.status == 200 &&
                            eval("(" + data.data + ")")[0].count > 0
                        ) {
                            self.history.getSuccess = true;
                            return;
                        } else {
                            if (data.rt.status == 400004) {
                                self.ui.error(lang.member_list_view_msg14);
                                return;
                            } else if (data.rt.status == 400005) {
                                self.ui.error(lang.member_list_view_msg15);
                                return;
                            }
                            self.ui.error(lang.member_list_view_msg16);
                        }
                    },
                    false
                );
            } else {
                self.ui.error(lang.member_list_view_msg17);
            }
        },
        // 加入团队
        joinTeam: function(teamId) {
            var url = "/v1/marker-recruit/team/apply";
            LoadAjax.method(url, { team_id: teamId }, "POST", function(data) {
                if (data == null || data == "") {
                    return;
                }
                if (data.rt.status == 200) {
                    self.ui.successGoBase(lang.member_list_view_msg18);
                } else if (data.rt.status == 100005) {
                    self.ui.fade(lang.member_list_view_msg18);
                } else if (data.rt.status == 100002) {
                    self.MessageBox.alert(
                        lang.member_list_view_msg19,
                        "操作提醒"
                    );
                } else {
                    self.ui.error(data.data);
                }
            });
        },
        // 是否可以参加任务
        canJoinTask: function(taskid, markstatus, step) {
            var self = this;
            //关闭弹窗
            self.closePop();
            // 是否是团队开放任务   1.完全开放2.勋章开放3.团队开放4.勋章和团队开放
            var authType = "";
            if (markstatus == 2) {
                authType = "medal";
            } else if (markstatus == 3) {
                authType = "team";
            } else if (markstatus == 4) {
                authType = "medal_team";
            } else if (markstatus == 1) {
                authType = "public";
            }
            // 检查用户是否有权限参加任务
            LoadAjax.method(
                "/v1/task/can-join",
                { taskId: taskid, authType: authType, step: step },
                "GET",
                function(data) {
                    var res = data;
                    if (res == null || res == "") {
                        self.ui.error(lang.member_list_view_msg2);
                        return;
                    }
                    if (res.rt.status != 200) {
                        self.ui.error(result.data);
                        return;
                    }
                    if (res.data == null || res.data == "") {
                        self.ui.error(lang.member_list_view_msg2);
                        return;
                    }
                    if (res.rt.status == 200) {
                        if (step == 0) {
                            if (res.data.code == 2) {
                                if (
                                    res.data.team != null &&
                                    res.data.team != ""
                                ) {
                                    ui.confirm(
                                        lang.member_list_view_msg3,
                                        function() {
                                            self.joinTeam(res.data.team);
                                        }
                                    );
                                } else if (
                                    res.data.medal != null &&
                                    res.data.medal != ""
                                ) {
                                    ui.confirm(
                                        lang.member_list_view_msg4,
                                        function() {
                                            window.open(
                                                "/assets/home/medal-page/?medal_id=" +
                                                    res.data.medal
                                            );
                                        }
                                    );
                                } else {
                                    self.ui.fade(lang.member_list_view_msg5);
                                }
                                return;
                            }
                            if (res.data.code == 3) {
                                self.ui.error(lang.member_list_view_msg6);
                                return;
                            }
                            if (res.data.code == 4) {
                                ui.message(lang.member_list_view_msg7);
                                return;
                            }
                            if (res.data.code == 1) {
                                self.doApply(taskid, step, self.countVal);
                            }
                        } else if (step == 1) {
                            // 检查
                            if (res.data.code == 2) {
                                ui.message(lang.member_list_view_msg8);
                                return;
                            }
                            if (res.data.code == 3) {
                                self.ui.error(lang.member_list_view_msg9);
                                return;
                            }
                            if (res.data.code == 4) {
                                ui.message(lang.member_list_view_msg7);
                                return;
                            }
                            if (res.data.code == 1) {
                                self.doApply(taskid, step, null);
                            }
                        }
                    }
                }
            );
        },
        apply: function() {
            var self = this;
            if (self.apply_type == "custom" && self.task_type == "mark") {
                // 自定义数量申请
                if (self.countVal == null || self.countVal == "") {
                    if (!$("input[name='lab_val']").hasClass("err")) {
                        $("input[name='lab_val']")
                            .removeClass("yes")
                            .addClass("err")
                            .after(
                                "<div class='error'>" +
                                    lang.member_list_view_msg10 +
                                    "</div>"
                            );
                    }
                    return;
                }
                if (
                    this.countVal < this.single_min ||
                    this.countVal > this.single_max
                ) {
                    this.countVal = this.single_min;
                    if (!$("input[name='lab_val']").hasClass("err")) {
                        $("input[name='lab_val']")
                            .removeClass("yes")
                            .addClass("err")
                            .after(
                                '<div class="error"><var>' +
                                    lang.member_list_view_msg11 +
                                    "</var>" +
                                    this.single_min +
                                    " - " +
                                    this.single_max +
                                    "<var>" +
                                    lang.member_list_view_msg12 +
                                    "</var></div>"
                            );
                    }
                    return;
                }
            }
            var step = this.task_type == "mark" ? 0 : 1;
            this.canJoinTask(this.base.taskId, this.markstatus, step);
        },
        closePop: function() {
            this.history.hidePop = false;
        },
        // 加入任务
        joinTask: function() {
            var self = this;
            this.history.hidePop = true;
            this.getMytaskList();
            var proxyurl = "/v1/task/detail?taskId=";
            LoadAjax.method(proxyurl + this.base.taskId, "", "GET", function(
                data
            ) {
                if (data.rt.status == 200) {
                    self.task = data.data;
                    self.history.submitsuccess = false;
                    // 检查用户是否有权限申请任务
                    self.apply_type =
                        self.task.countlevel == undefined ||
                        self.task.countlevel == ""
                            ? "custom"
                            : "gradient";
                    if (self.apply_type == "gradient") {
                        self.count_level = self.task.countlevel.split(";");
                        // 排序
                        self.count_level = self.count_level.sort(function(
                            a,
                            b
                        ) {
                            return a - b;
                        });
                        self.countVal = self.count_level[0];
                    }
                    self.single_min = self.task.singlemin;
                    self.single_max = self.task.singlemax;
                } else {
                    self.ui.error(lang.member_list_view_msg1);
                }
            });
        },
        changeTab: function(index) {
            this.task_type = index;
        }
    },
    filters: {
        formatTime: function(val) {
            // return parseFloat(val + '').toFixed(2)
            if (!!!val) return "00:00";
            var zNum = val < 1 ? Math.ceil(val) : parseInt(val);
            return (
                parseInt(zNum / 60) +
                ":" +
                (parseInt(zNum % 60) < 10
                    ? "0" + parseInt(zNum % 60)
                    : parseInt(zNum % 60))
            );
        },
        toDateTime: function(_value) {
            // 时间转换器
            if (_value == undefined) return "--";
            return self.Utils.toDateTime(_value);
        },
        takeTwoDecimal: function(val) {
            var type = typeof val;
            if (type !== "number") {
                return "100%";
            }
            return Math.ceil((val * 100).toFixed(2)) + "%";
        },
        attrTitle: function(item) {
            if (!self.checkType) return "";
            return !!item.type
                ? self.checkType[item.type]
                : item.unfold ? "" : item.text;
        }
    },
    components: {
        Header,
        CenterControl,
        Tool,
        FileList,
        HistoryPopup,
        MarkContent,
    }
};

</script>
     
<style scoped>
@import "../assets/css/jingxihua/index.css";
/* @import "~@/assets/css/common/bottomControl.css"; */
@import "~@/assets/css/common/work-team-common.css";
</style>
